/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.controller;

import com.persistencia.domain.*;
import com.service.AsignaturaService;
import com.service.AsignaturaprerequisitoService;
import com.service.DocenteService;
import com.service.PersonaService;
import com.service.impl.AsignaturaServiceImpl;
import com.service.impl.AsignaturaprerequisitoServiceImpl;
import com.service.impl.DocenteServiceImpl;
import com.service.impl.PersonaServiceImpl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import org.primefaces.event.SelectEvent;
import org.primefaces.model.DualListModel;

/**
 *
 * @author kenny
 */
@ManagedBean
@ViewScoped
public class AsignaturaController {
    private List<Asignatura> lista = new ArrayList<Asignatura>();
    private Asignatura asignaturaseleccionado;
    private Asignaturaprerequisito asignaturaprerequisito;
    private Asignatura asignaturanuevo;
    private AsignaturaService asignaturaService;
    private AsignaturaprerequisitoPK asignaturaprerequisitoPK;
    private AsignaturaprerequisitoService asignaturaprerequisitoService;
    private DualListModel<String> listaDual;
    private List<String> source;
    private List<String> target;
    private String codigo="";
    private List<String> sourceAux;
    private List<String> targetAux;
    /**
     * Creates a new instance of DocenteController
     */
    public AsignaturaController() {
        asignaturaseleccionado = new Asignatura();
        asignaturanuevo = new Asignatura();
        asignaturaService = new AsignaturaServiceImpl();
        asignaturaprerequisitoService = new AsignaturaprerequisitoServiceImpl();
        asignaturaprerequisito = new Asignaturaprerequisito();
        asignaturaprerequisitoPK = new AsignaturaprerequisitoPK();
        cargar();
    }
    
    public void cargar(){
        try {
            //docenteseleccionado = new Docente();
            
            //lista = docenteService.obtenerListaDocentes();
            lista = asignaturaService.buscarAsignaturas();
            //lista = docenteService.buscarDocentes();
            source = new ArrayList<String>();
            target = new ArrayList<String>();
            for (Asignatura asig : lista){
                source.add(asig.getVNombre());
            }
            listaDual = new DualListModel<String>(source, target);
        } catch (Exception ex) {
            Logger.getLogger(AsignaturaController.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    /*public void pasarparametros(SelectEvent event) {
        System.out.println("Entramos");
        asignaturaseleccionado = (Asignatura) event.getObject();
        
        
 
    }*/
    
    public void eliminar(){
        if(asignaturaseleccionado!=null){
            try {
                System.out.println("Entramos a eliminar");          
                    System.out.println("Docente Seleccioando"+asignaturaseleccionado.getVCodigo());
                
                    asignaturaseleccionado.setVEstado("1");
                    asignaturaService.actualizarAsignatura(asignaturaseleccionado);
                    //controladortrabajos.edit(trabajo);
                       
                    FacesMessage msg = new FacesMessage("El Docente se elimino satisfactoriamente.");
                    FacesContext.getCurrentInstance().addMessage(null, msg);
                
                cargar();
            } catch (Exception ex) {
                Logger.getLogger(AsignaturaController.class.getName()).log(Level.SEVERE, null, ex);
            }
       }else{
            System.out.println("No se ha seleccionado un docente");
            FacesMessage msg = new FacesMessage("Error: Debe Seleccionar un Docente");  
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
        
    }
    
    public void editar(){
        try {
                
                asignaturaService.actualizarAsignatura(asignaturaseleccionado);
                          
                FacesMessage msg = new FacesMessage("El Docente se elimino satisfactoriamente.");
                FacesContext.getCurrentInstance().addMessage(null, msg);
                //JsfUtil.addErrorMessage(ResourceBundle.getBundle("/Bundle").getString("proyectoCreado"));
                cargar();
        } catch (Exception ex) {
            Logger.getLogger(AsignaturaController.class.getName()).log(Level.SEVERE, null, ex);
        }       
    }
    
    public void asignar(){
        try {
                target = listaDual.getTarget();
        
        Asignatura[] asigelegidas = new Asignatura[target.size()];
        
        for (int k = 0; k < target.size(); k++){
            asigelegidas[k] = (Asignatura)asignaturaService.buscarAsignaturasxNombre(target.get(k));
        }
        
        for (int k = 0; k < target.size(); k++){
            
            System.out.println("Id Seleccionado: " +asignaturaseleccionado.getNAsgId());
            System.out.println("Id elegida: " +asigelegidas[k].getNAsgId());
            
            System.out.println("Codigo: " +asigelegidas[k].getVCodigo());
            System.out.println("Nombre: " + asigelegidas[k].getVNombre());
            
          //asignaturaprerequisito.setAsignatura(asignaturaseleccionado);
           // asignaturaprerequisito.setAsignatura1(asigelegidas[k]);
            
            asignaturaprerequisitoPK.setNAsgId(asignaturaseleccionado.getNAsgId());
            asignaturaprerequisitoPK.setNAsgPreRqsId(asigelegidas[k].getNAsgId());
            
            asignaturaprerequisito.setAsignaturaprerequisitoPK(asignaturaprerequisitoPK);
            asignaturaprerequisito.setVEstado("0");
            asignaturaprerequisitoService.registrarAsignaturaprerequisito(asignaturaprerequisito);
            
            asignaturaprerequisitoPK = new AsignaturaprerequisitoPK();
            asignaturaprerequisito = new Asignaturaprerequisito();
            /*opcionesUsuario.setIdOpcion(targetOpciones[k]);
            opcionesUsuario.setIdUsuario(usuario);
            opcionesUsuario.setEstado("ACTIVO");
            opcionesUsuario.setFechaRegistro(fecha);
            opcionesUsuario.setFechaModificacion(fecha);
            controladorOpcionesUsuario.create(opcionesUsuario);*/
        }
                
                //asignaturaService.actualizarAsignatura(asignaturaseleccionado);
                          
                FacesMessage msg = new FacesMessage("Se grabo satisfactoriamente.");
                FacesContext.getCurrentInstance().addMessage(null, msg);
                //JsfUtil.addErrorMessage(ResourceBundle.getBundle("/Bundle").getString("proyectoCreado"));
                cargar();
        } catch (Exception ex) {
            Logger.getLogger(AsignaturaController.class.getName()).log(Level.SEVERE, null, ex);
        }       
    }
    
    public void nuevo(){
        
            System.out.println("Entramos a crear aisgnatura");
            
            source = listaDual.getSource();
            target = listaDual.getTarget();
            List<String> targetEliminar = new ArrayList<String>();//seran al final las opciones a eliminar
            for (String s : targetAux){
                targetEliminar.add(s);
            }
            System.out.println("Entramos a crear aisgnatura1");
            //Algoritmo que determina la lista de target a eliminar de la base de datos
            for (int i = 0; i < target.size(); i++){
                for (int j = 0; j < targetEliminar.size(); j++){
                    if (target.get(i).equals(targetEliminar.get(j))){
                        targetEliminar.remove(j);
                    }
                }
            }
            System.out.println("Entramos a crear aisgnatura2");
            List<String> targetAnterior = new ArrayList<String>(); //= targetAux;
            for (String s : targetAux){
                targetAnterior.add(s);
            }
            
            List<String> targetNuevo = new ArrayList<String>();//Seran al final las nuevas opciones a crear
            for (String s : target){
                targetNuevo.add(s);
            }
            System.out.println("Entramos a crear aisgnatura3");
            //Algoritmo que determina la lista de target que seran agregadas a la base de datos
            for (int i = 0; i < targetAnterior.size(); i++){
                for (int j = 0; j < targetNuevo.size(); j++){
                    if (targetAnterior.get(i).equals(targetNuevo.get(j))){
                        targetNuevo.remove(j);
                    }
                }
            }
            System.out.println("Entramos a crear aisgnatura4");
            if (!targetNuevo.isEmpty()){
                List<Asignatura> listaAsignaturaAgregar = new ArrayList<Asignatura>();// = (List<Opciones>)controladorOpciones.findOpciones(campo);
                for (int i = 0; i < targetNuevo.size(); i++){
                    Asignatura asig = (Asignatura)asignaturaService.buscarAsignaturasxNombre(targetNuevo.get(i));
                    if (asig != null){
                        listaAsignaturaAgregar.add(asig);
                    }
                }
                for (int i = 0; i < listaAsignaturaAgregar.size(); i++){
                try {
                    asignaturaprerequisitoPK.setNAsgId(asignaturaseleccionado.getNAsgId());
                    asignaturaprerequisitoPK.setNAsgPreRqsId(listaAsignaturaAgregar.get(i).getNAsgId());

                    asignaturaprerequisito.setAsignaturaprerequisitoPK(asignaturaprerequisitoPK);
                    asignaturaprerequisito.setVEstado("0");
                    asignaturaprerequisitoService.registrarAsignaturaprerequisito(asignaturaprerequisito);

                    asignaturaprerequisitoPK = new AsignaturaprerequisitoPK();
                    asignaturaprerequisito = new Asignaturaprerequisito();
                } catch (Exception ex) {
                    Logger.getLogger(AsignaturaController.class.getName()).log(Level.SEVERE, null, ex);
                }
                }
            }
            System.out.println("Entramos a crear aisgnatura5");
            if (!targetEliminar.isEmpty()){
            List<Asignatura> listaAsignaturaEliminar = new ArrayList<Asignatura>();
            for (int i = 0; i < targetEliminar.size(); i++){
                Asignatura asig = (Asignatura)asignaturaService.buscarAsignaturasxNombre(targetEliminar.get(i));
                if (asig != null){
                    listaAsignaturaEliminar.add(asig);
                }
            }
            List<Asignaturaprerequisito> listaAsignaturasEliminar = new ArrayList<Asignaturaprerequisito>();
            for (int i = 0; i < listaAsignaturaEliminar.size(); i++){
                Asignaturaprerequisito asigpre = (Asignaturaprerequisito)asignaturaprerequisitoService.buscarPrerequisitosxIdAsignaturas(asignaturaseleccionado.getNAsgId(), listaAsignaturaEliminar.get(i).getNAsgId());
                listaAsignaturasEliminar.add(asigpre);
            }
            /*List<Integer> idOpcionesUsuarioEliminar = new ArrayList<Integer>();
            for (int i = 0; i < listaOpcionesUsuarioEliminar.size(); i++){
                idOpcionesUsuarioEliminar.add(listaOpcionesUsuarioEliminar.get(i).getIdUsuarioOpcion());
            }*/
            System.out.println("Entramos a crear aisgnatura6");
            for (int i = 0; i < listaAsignaturasEliminar.size(); i++){
                try {
                    asignaturaprerequisitoService.eliminarAsignaturaprerequisito(listaAsignaturasEliminar.get(i));
                } catch (Exception ex) {
                    Logger.getLogger(AsignaturaController.class.getName()).log(Level.SEVERE, null, ex);
                }
               
            }
            System.out.println("Entramos a crear aisgnatura7");
                FacesMessage msg = new FacesMessage("El Asignatura creada satisfactoriamente.");
                FacesContext.getCurrentInstance().addMessage(null, msg);
                //cargar();
        
            }
            System.out.println("Entramos a crear aisgnatura8");
    }
    
    public void cargarprerequisitos(){
        
        System.out.println("sssss" + asignaturaseleccionado.getNAsgId());
        List<Asignaturaprerequisito> listpretarget = (List<Asignaturaprerequisito>)asignaturaprerequisitoService.buscarPrerequisitosxIdAsignaturas(asignaturaseleccionado.getNAsgId());
        /*for (Asignaturaprerequisito asig : listpretarget){
               System.out.println("Codigo id: " +asig.getAsignatura1().getNAsgId() + "Codigo pre: "+asig.getAsignatura().getNAsgId());
        }*/
        List<Asignatura> listapresource = asignaturaService.buscarAsignaturas();
        //List<PrivilegiosUsuario> listPrivUser = (List<PrivilegiosUsuario>)controladorPrivilegiosUsuario.findPrivilegiosUsuario(user);
        listaDual = null;
        //List<Opciones> opc = (List<Opciones>)controladorOpciones.findOpcionesEntities();
        source = new ArrayList<String>();
        target = new ArrayList<String>();
        if (listpretarget != null){
            for (Asignaturaprerequisito asig : listpretarget){
                target.add(asig.getAsignatura().getVNombre());
            }
            for (int i = 0; i < listpretarget.size(); i++){
                for (int j = 0; j < listapresource.size(); j++){
                    if (listpretarget.get(i).getAsignatura().getNAsgId() == listapresource.get(j).getNAsgId() ){
                        listapresource.remove(j);
                    }
                }
            }
        }
        for (Asignatura asig : listapresource){
            source.add(asig.getVNombre());
        }
        sourceAux = source;
        targetAux = target;
        //Collections.sort(source);
        //Collections.sort(target);
        listaDual = new DualListModel<String>(source, target);
        System.out.println("ddddddddddddddddddd");
    }

    public List<Asignatura> getLista() {
        return lista;
    }

    public void setLista(List<Asignatura> lista) {
        this.lista = lista;
    }

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public Asignatura getAsignaturanuevo() {
        return asignaturanuevo;
    }

    public void setAsignaturanuevo(Asignatura asignaturanuevo) {
        this.asignaturanuevo = asignaturanuevo;
    }

    public Asignatura getAsignaturaseleccionado() {
        
        return asignaturaseleccionado;
    }

    public void setAsignaturaseleccionado(Asignatura asignaturaseleccionado) {
        System.out.println("Entramos");
        
        this.asignaturaseleccionado = asignaturaseleccionado;
        cargarprerequisitos();
        System.out.println("Entramos111");
        
    }

    public DualListModel<String> getListaDual() {
        System.out.println("eeeeeeeeeeeeeeeeeeeee");
        return listaDual;
    }

    public void setListaDual(DualListModel<String> listaDual) {
        this.listaDual = listaDual;
    }
    
    
    
}
